
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
// 
//   http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

/**
 * AUTO-GENERATED FILE. DO NOT MODIFY.
 */

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
// 
//   http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
import { __extends } from 'tslib';
import * as zrUtil from 'zrender/lib/core/util.js';
import Scale from './Scale.js';
import * as numberUtil from '../util/number.js';
import * as scaleHelper from './helper.js'; // Use some method of IntervalScale

import IntervalScale from './Interval.js';
var scaleProto = Scale.prototype; // FIXME:TS refactor: not good to call it directly with `this`?

var intervalScaleProto = IntervalScale.prototype;
var roundingErrorFix = numberUtil.round;
var mathFloor = Math.floor;
var mathCeil = Math.ceil;
var mathPow = Math.pow;
var mathLog = Math.log;

var LogScale =
/** @class */
function (_super) {
	__extends(LogScale, _super);

	function LogScale() {
		var _this = _super !== null && _super.apply(this, arguments) || this;

		_this.type = 'log';
		_this.base = 10;
		_this._originalScale = new IntervalScale(); // FIXME:TS actually used by `IntervalScale`

		_this._interval = 0;
		return _this;
	}
	/**
   * @param Whether expand the ticks to niced extent.
   */

	LogScale.prototype.getTicks = function (expandToNicedExtent) {
		var originalScale = this._originalScale;
		var extent = this._extent;
		var originalExtent = originalScale.getExtent();
		var ticks = intervalScaleProto.getTicks.call(this, expandToNicedExtent);
		return zrUtil.map(ticks, function (tick) {
			var val = tick.value;
			var powVal = numberUtil.round(mathPow(this.base, val)); // Fix #4158

			powVal = val === extent[0] && this._fixMin ? fixRoundingError(powVal, originalExtent[0]) : powVal;
			powVal = val === extent[1] && this._fixMax ? fixRoundingError(powVal, originalExtent[1]) : powVal;
			return {
				value: powVal
			};
		}, this);
	};

	LogScale.prototype.setExtent = function (start, end) {
		var base = mathLog(this.base); // log(-Infinity) is NaN, so safe guard here

		start = mathLog(Math.max(0, start)) / base;
		end = mathLog(Math.max(0, end)) / base;
		intervalScaleProto.setExtent.call(this, start, end);
	};
	/**
   * @return {number} end
   */

	LogScale.prototype.getExtent = function () {
		var base = this.base;
		var extent = scaleProto.getExtent.call(this);
		extent[0] = mathPow(base, extent[0]);
		extent[1] = mathPow(base, extent[1]); // Fix #4158

		var originalScale = this._originalScale;
		var originalExtent = originalScale.getExtent();
		this._fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0]));
		this._fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1]));
		return extent;
	};

	LogScale.prototype.unionExtent = function (extent) {
		this._originalScale.unionExtent(extent);

		var base = this.base;
		extent[0] = mathLog(extent[0]) / mathLog(base);
		extent[1] = mathLog(extent[1]) / mathLog(base);
		scaleProto.unionExtent.call(this, extent);
	};

	LogScale.prototype.unionExtentFromData = function (data, dim) {
		// TODO
		// filter value that <= 0
		this.unionExtent(data.getApproximateExtent(dim));
	};
	/**
   * Update interval and extent of intervals for nice ticks
   * @param approxTickNum default 10 Given approx tick number
   */

	LogScale.prototype.calcNiceTicks = function (approxTickNum) {
		approxTickNum = approxTickNum || 10;
		var extent = this._extent;
		var span = extent[1] - extent[0];

		if (span === Infinity || span <= 0) {
			return;
		}

		var interval = numberUtil.quantity(span);
		var err = approxTickNum / span * interval; // Filter ticks to get closer to the desired count.

		if (err <= 0.5) {
			interval *= 10;
		} // Interval should be integer

		while (!isNaN(interval) && Math.abs(interval) < 1 && Math.abs(interval) > 0) {
			interval *= 10;
		}

		var niceExtent = [numberUtil.round(mathCeil(extent[0] / interval) * interval), numberUtil.round(mathFloor(extent[1] / interval) * interval)];
		this._interval = interval;
		this._niceExtent = niceExtent;
	};

	LogScale.prototype.calcNiceExtent = function (opt) {
		intervalScaleProto.calcNiceExtent.call(this, opt);
		this._fixMin = opt.fixMin;
		this._fixMax = opt.fixMax;
	};

	LogScale.prototype.parse = function (val) {
		return val;
	};

	LogScale.prototype.contain = function (val) {
		val = mathLog(val) / mathLog(this.base);
		return scaleHelper.contain(val, this._extent);
	};

	LogScale.prototype.normalize = function (val) {
		val = mathLog(val) / mathLog(this.base);
		return scaleHelper.normalize(val, this._extent);
	};

	LogScale.prototype.scale = function (val) {
		val = scaleHelper.scale(val, this._extent);
		return mathPow(this.base, val);
	};

	LogScale.type = 'log';
	return LogScale;
}(Scale);

var proto = LogScale.prototype;
proto.getMinorTicks = intervalScaleProto.getMinorTicks;
proto.getLabel = intervalScaleProto.getLabel;

function fixRoundingError(val, originalVal) {
	return roundingErrorFix(val, numberUtil.getPrecision(originalVal));
}

Scale.registerClass(LogScale);
export default LogScale;